// /*
//  * modbus_rtu.c - Modbus RTU 从设备驱动实现文件
//  * 适用于MSPM0G3507微控制器
//  * 专为4G模块与下位机通信设计
//  */

// #include "modbus_rtu.h"
// #include "Driver/CLOCK/clock.h"
// #include <string.h>
// #include <stdio.h>

// // 全局默认Modbus句柄
// ModbusRTU_Handle_t g_modbus_handle;

// // 私有函数声明
// static ModbusStatus_t ModbusRTU_ParseFrame(ModbusRTU_Handle_t *handle);
// static ModbusStatus_t ModbusRTU_ProcessReadHoldingRegisters(ModbusRTU_Handle_t *handle, uint16_t start_addr, uint16_t quantity);
// static ModbusStatus_t ModbusRTU_ProcessReadInputRegisters(ModbusRTU_Handle_t *handle, uint16_t start_addr, uint16_t quantity);
// static ModbusStatus_t ModbusRTU_ProcessReadCoils(ModbusRTU_Handle_t *handle, uint16_t start_addr, uint16_t quantity);
// static ModbusStatus_t ModbusRTU_ProcessReadDiscreteInputs(ModbusRTU_Handle_t *handle, uint16_t start_addr, uint16_t quantity);
// static ModbusStatus_t ModbusRTU_ProcessWriteSingleRegister(ModbusRTU_Handle_t *handle, uint16_t addr, uint16_t value);
// static ModbusStatus_t ModbusRTU_ProcessWriteSingleCoil(ModbusRTU_Handle_t *handle, uint16_t addr, uint16_t value);
// static ModbusStatus_t ModbusRTU_SendResponse(ModbusRTU_Handle_t *handle, uint8_t *data, uint16_t length);
// static ModbusStatus_t ModbusRTU_SendException(ModbusRTU_Handle_t *handle, uint8_t function_code, uint8_t exception_code);
// static uint32_t ModbusRTU_GetTick(void);
// static bool ModbusRTU_IsFrameComplete(ModbusRTU_Handle_t *handle);

// /**
//  * @brief 初始化Modbus RTU从设备
//  */
// ModbusStatus_t ModbusRTU_Init(ModbusRTU_Handle_t *handle, UART_4G_Handle_t *uart_handle, uint8_t slave_addr)
// {
//     if (handle == NULL || uart_handle == NULL) {
//         return MODBUS_STATUS_ERROR;
//     }

//     // 初始化句柄
//     handle->uart_handle = uart_handle;
//     handle->slave_address = slave_addr;
//     handle->rx_count = 0;
//     handle->frame_ready = false;
//     handle->last_char_time = ModbusRTU_GetTick();

//     // 清空缓冲区
//     memset(handle->rx_buffer, 0, sizeof(handle->rx_buffer));
//     memset(handle->tx_buffer, 0, sizeof(handle->tx_buffer));

//     // 初始化寄存器
//     memset(handle->holding_registers, 0, sizeof(handle->holding_registers));
//     memset(handle->input_registers, 0, sizeof(handle->input_registers));
//     memset(handle->coils, 0, sizeof(handle->coils));
//     memset(handle->discrete_inputs, 0, sizeof(handle->discrete_inputs));

//     // 设置一个默认的温度值（25.5°C，扩大10倍为255）
//     handle->holding_registers[0] = 255;
//     handle->input_registers[0] = 255;

//     return MODBUS_STATUS_OK;
// }

// /**
//  * @brief 反初始化Modbus RTU从设备
//  */
// ModbusStatus_t ModbusRTU_DeInit(ModbusRTU_Handle_t *handle)
// {
//     if (handle == NULL) {
//         return MODBUS_STATUS_ERROR;
//     }

//     handle->uart_handle = NULL;
//     handle->slave_address = 0;
//     handle->rx_count = 0;
//     handle->frame_ready = false;

//     return MODBUS_STATUS_OK;
// }

// /**
//  * @brief 处理单个接收字符
//  */
// ModbusStatus_t ModbusRTU_ProcessReceivedChar(ModbusRTU_Handle_t *handle, uint8_t ch)
// {
//     if (handle == NULL) {
//         return MODBUS_STATUS_ERROR;
//     }

//     uint32_t current_time = ModbusRTU_GetTick();

//     // 如果距离上次字符接收时间过长，重新开始接收帧
//     if (current_time - handle->last_char_time > 5) { // 5ms间隔作为帧间隔
//         handle->rx_count = 0;
//         handle->frame_ready = false;
//     }

//     // 添加字符到接收缓冲区
//     if (handle->rx_count < MODBUS_BUFFER_SIZE) {
//         handle->rx_buffer[handle->rx_count++] = ch;
//         handle->last_char_time = current_time;
//     } else {
//         // 缓冲区溢出，重置
//         handle->rx_count = 0;
//         handle->frame_ready = false;
//         return MODBUS_STATUS_ERROR;
//     }

//     return MODBUS_STATUS_OK;
// }

// /**
//  * @brief 处理接收到的数据
//  */
// ModbusStatus_t ModbusRTU_ProcessReceivedData(ModbusRTU_Handle_t *handle, uint8_t *data, uint16_t length)
// {
//     if (handle == NULL || data == NULL || length == 0) {
//         return MODBUS_STATUS_ERROR;
//     }

//     for (uint16_t i = 0; i < length; i++) {
//         ModbusRTU_ProcessReceivedChar(handle, data[i]);
//     }

//     return MODBUS_STATUS_OK;
// }

// /**
//  * @brief 主处理循环，检查并处理完整帧
//  */
// ModbusStatus_t ModbusRTU_Process(ModbusRTU_Handle_t *handle)
// {
//     if (handle == NULL) {
//         return MODBUS_STATUS_ERROR;
//     }

//     // 检查是否有完整的帧
//     if (ModbusRTU_IsFrameComplete(handle)) {
//         handle->frame_ready = true;
//         return ModbusRTU_ParseFrame(handle);
//     }

//     return MODBUS_STATUS_OK;
// }

// /**
//  * @brief 计算CRC16校验值
//  */
// uint16_t ModbusRTU_CalculateCRC16(uint8_t *data, uint16_t length)
// {
//     uint16_t crc = 0xFFFF;
    
//     for (uint16_t i = 0; i < length; i++) {
//         crc ^= data[i];
//         for (uint8_t j = 0; j < 8; j++) {
//             if (crc & 0x0001) {
//                 crc = (crc >> 1) ^ MODBUS_CRC16_POLY;
//             } else {
//                 crc >>= 1;
//             }
//         }
//     }
    
//     return crc;
// }

// /**
//  * @brief 验证CRC16校验值
//  */
// bool ModbusRTU_VerifyCRC16(uint8_t *data, uint16_t length)
// {
//     if (data == NULL || length < 3) {
//         return false;
//     }

//     uint16_t calculated_crc = ModbusRTU_CalculateCRC16(data, length - 2);
//     uint16_t received_crc = (uint16_t)(data[length - 2] | (data[length - 1] << 8));

//     return (calculated_crc == received_crc);
// }

// /**
//  * @brief 设置保持寄存器值
//  */
// ModbusStatus_t ModbusRTU_SetHoldingRegister(ModbusRTU_Handle_t *handle, uint16_t addr, uint16_t value)
// {
//     if (handle == NULL || addr >= MODBUS_MAX_REGISTERS) {
//         return MODBUS_STATUS_INVALID_ADDRESS;
//     }

//     handle->holding_registers[addr] = value;
//     return MODBUS_STATUS_OK;
// }

// /**
//  * @brief 获取保持寄存器值
//  */
// ModbusStatus_t ModbusRTU_GetHoldingRegister(ModbusRTU_Handle_t *handle, uint16_t addr, uint16_t *value)
// {
//     if (handle == NULL || value == NULL || addr >= MODBUS_MAX_REGISTERS) {
//         return MODBUS_STATUS_INVALID_ADDRESS;
//     }

//     *value = handle->holding_registers[addr];
//     return MODBUS_STATUS_OK;
// }

// /**
//  * @brief 设置输入寄存器值
//  */
// ModbusStatus_t ModbusRTU_SetInputRegister(ModbusRTU_Handle_t *handle, uint16_t addr, uint16_t value)
// {
//     if (handle == NULL || addr >= MODBUS_MAX_REGISTERS) {
//         return MODBUS_STATUS_INVALID_ADDRESS;
//     }

//     handle->input_registers[addr] = value;
//     return MODBUS_STATUS_OK;
// }

// /**
//  * @brief 获取输入寄存器值
//  */
// ModbusStatus_t ModbusRTU_GetInputRegister(ModbusRTU_Handle_t *handle, uint16_t addr, uint16_t *value)
// {
//     if (handle == NULL || value == NULL || addr >= MODBUS_MAX_REGISTERS) {
//         return MODBUS_STATUS_INVALID_ADDRESS;
//     }

//     *value = handle->input_registers[addr];
//     return MODBUS_STATUS_OK;
// }

// /**
//  * @brief 设置线圈状态
//  */
// ModbusStatus_t ModbusRTU_SetCoil(ModbusRTU_Handle_t *handle, uint16_t addr, bool value)
// {
//     if (handle == NULL || addr >= MODBUS_MAX_REGISTERS) {
//         return MODBUS_STATUS_INVALID_ADDRESS;
//     }

//     uint16_t byte_index = addr / 8;
//     uint8_t bit_index = addr % 8;

//     if (value) {
//         handle->coils[byte_index] |= (1 << bit_index);
//     } else {
//         handle->coils[byte_index] &= ~(1 << bit_index);
//     }

//     return MODBUS_STATUS_OK;
// }

// /**
//  * @brief 获取线圈状态
//  */
// ModbusStatus_t ModbusRTU_GetCoil(ModbusRTU_Handle_t *handle, uint16_t addr, bool *value)
// {
//     if (handle == NULL || value == NULL || addr >= MODBUS_MAX_REGISTERS) {
//         return MODBUS_STATUS_INVALID_ADDRESS;
//     }

//     uint16_t byte_index = addr / 8;
//     uint8_t bit_index = addr % 8;

//     *value = (handle->coils[byte_index] & (1 << bit_index)) != 0;

//     return MODBUS_STATUS_OK;
// }

// /**
//  * @brief 快速设置温度数据到寄存器0
//  */
// ModbusStatus_t ModbusRTU_SetTemperature(ModbusRTU_Handle_t *handle, uint16_t temperature)
// {
//     if (handle == NULL) {
//         return MODBUS_STATUS_ERROR;
//     }

//     handle->holding_registers[0] = temperature;
//     handle->input_registers[0] = temperature;

//     return MODBUS_STATUS_OK;
// }

// /**
//  * @brief 获取温度数据从寄存器0
//  */
// ModbusStatus_t ModbusRTU_GetTemperature(ModbusRTU_Handle_t *handle, uint16_t *temperature)
// {
//     if (handle == NULL || temperature == NULL) {
//         return MODBUS_STATUS_ERROR;
//     }

//     *temperature = handle->holding_registers[0];

//     return MODBUS_STATUS_OK;
// }

// // 私有函数实现

// /**
//  * @brief 解析接收到的Modbus帧
//  */
// static ModbusStatus_t ModbusRTU_ParseFrame(ModbusRTU_Handle_t *handle)
// {
//     if (handle == NULL || handle->rx_count < 4) {
//         return MODBUS_STATUS_ERROR;
//     }

//     // 验证CRC
//     if (!ModbusRTU_VerifyCRC16(handle->rx_buffer, handle->rx_count)) {
//         handle->rx_count = 0;
//         handle->frame_ready = false;
//         return MODBUS_STATUS_CRC_ERROR;
//     }

//     uint8_t slave_addr = handle->rx_buffer[0];
//     uint8_t function_code = handle->rx_buffer[1];

//     // 检查从设备地址
//     if (slave_addr != handle->slave_address && slave_addr != 0) {
//         handle->rx_count = 0;
//         handle->frame_ready = false;
//         return MODBUS_STATUS_OK; // 不是发给我们的，忽略
//     }

//     // 解析数据字段
//     uint16_t start_addr = (handle->rx_buffer[2] << 8) | handle->rx_buffer[3];
//     uint16_t quantity = (handle->rx_buffer[4] << 8) | handle->rx_buffer[5];

//     ModbusStatus_t status = MODBUS_STATUS_OK;

//     // 根据功能码处理请求
//     switch (function_code) {
//         case MODBUS_FC_READ_HOLDING_REGS:
//             status = ModbusRTU_ProcessReadHoldingRegisters(handle, start_addr, quantity);
//             break;

//         case MODBUS_FC_READ_INPUT_REGS:
//             status = ModbusRTU_ProcessReadInputRegisters(handle, start_addr, quantity);
//             break;

//         case MODBUS_FC_READ_COILS:
//             status = ModbusRTU_ProcessReadCoils(handle, start_addr, quantity);
//             break;

//         case MODBUS_FC_READ_DISCRETE_INPUT:
//             status = ModbusRTU_ProcessReadDiscreteInputs(handle, start_addr, quantity);
//             break;

//         case MODBUS_FC_WRITE_SINGLE_REG:
//             if (handle->rx_count >= 8) {
//                 uint16_t value = (handle->rx_buffer[4] << 8) | handle->rx_buffer[5];
//                 status = ModbusRTU_ProcessWriteSingleRegister(handle, start_addr, value);
//             }
//             break;

//         case MODBUS_FC_WRITE_SINGLE_COIL:
//             if (handle->rx_count >= 8) {
//                 uint16_t value = (handle->rx_buffer[4] << 8) | handle->rx_buffer[5];
//                 status = ModbusRTU_ProcessWriteSingleCoil(handle, start_addr, value);
//             }
//             break;

//         default:
//             ModbusRTU_SendException(handle, function_code, MODBUS_EXCEPTION_ILLEGAL_FUNCTION);
//             break;
//     }

//     // 重置接收缓冲区
//     handle->rx_count = 0;
//     handle->frame_ready = false;

//     return status;
// }

// /**
//  * @brief 处理读取保持寄存器请求
//  */
// static ModbusStatus_t ModbusRTU_ProcessReadHoldingRegisters(ModbusRTU_Handle_t *handle, uint16_t start_addr, uint16_t quantity)
// {
//     if (start_addr + quantity > MODBUS_MAX_REGISTERS || quantity == 0 || quantity > 125) {
//         return ModbusRTU_SendException(handle, MODBUS_FC_READ_HOLDING_REGS, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS);
//     }

//     // 构造响应
//     handle->tx_buffer[0] = handle->slave_address;
//     handle->tx_buffer[1] = MODBUS_FC_READ_HOLDING_REGS;
//     handle->tx_buffer[2] = quantity * 2; // 字节数

//     // 填充寄存器数据
//     for (uint16_t i = 0; i < quantity; i++) {
//         uint16_t reg_value = handle->holding_registers[start_addr + i];
//         handle->tx_buffer[3 + i * 2] = (reg_value >> 8) & 0xFF;     // 高字节
//         handle->tx_buffer[4 + i * 2] = reg_value & 0xFF;            // 低字节
//     }

//     uint16_t response_length = 3 + quantity * 2;

//     // 添加CRC
//     uint16_t crc = ModbusRTU_CalculateCRC16(handle->tx_buffer, response_length);
//     handle->tx_buffer[response_length] = crc & 0xFF;         // CRC低字节
//     handle->tx_buffer[response_length + 1] = (crc >> 8) & 0xFF;  // CRC高字节

//     return ModbusRTU_SendResponse(handle, handle->tx_buffer, response_length + 2);
// }

// /**
//  * @brief 处理读取输入寄存器请求
//  */
// static ModbusStatus_t ModbusRTU_ProcessReadInputRegisters(ModbusRTU_Handle_t *handle, uint16_t start_addr, uint16_t quantity)
// {
//     if (start_addr + quantity > MODBUS_MAX_REGISTERS || quantity == 0 || quantity > 125) {
//         return ModbusRTU_SendException(handle, MODBUS_FC_READ_INPUT_REGS, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS);
//     }

//     // 构造响应
//     handle->tx_buffer[0] = handle->slave_address;
//     handle->tx_buffer[1] = MODBUS_FC_READ_INPUT_REGS;
//     handle->tx_buffer[2] = quantity * 2; // 字节数

//     // 填充寄存器数据
//     for (uint16_t i = 0; i < quantity; i++) {
//         uint16_t reg_value = handle->input_registers[start_addr + i];
//         handle->tx_buffer[3 + i * 2] = (reg_value >> 8) & 0xFF;     // 高字节
//         handle->tx_buffer[4 + i * 2] = reg_value & 0xFF;            // 低字节
//     }

//     uint16_t response_length = 3 + quantity * 2;

//     // 添加CRC
//     uint16_t crc = ModbusRTU_CalculateCRC16(handle->tx_buffer, response_length);
//     handle->tx_buffer[response_length] = crc & 0xFF;         // CRC低字节
//     handle->tx_buffer[response_length + 1] = (crc >> 8) & 0xFF;  // CRC高字节

//     return ModbusRTU_SendResponse(handle, handle->tx_buffer, response_length + 2);
// }

// /**
//  * @brief 处理读取线圈请求
//  */
// static ModbusStatus_t ModbusRTU_ProcessReadCoils(ModbusRTU_Handle_t *handle, uint16_t start_addr, uint16_t quantity)
// {
//     if (start_addr + quantity > MODBUS_MAX_REGISTERS || quantity == 0 || quantity > 2000) {
//         return ModbusRTU_SendException(handle, MODBUS_FC_READ_COILS, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS);
//     }

//     // 构造响应
//     handle->tx_buffer[0] = handle->slave_address;
//     handle->tx_buffer[1] = MODBUS_FC_READ_COILS;
//     uint8_t byte_count = (quantity + 7) / 8;
//     handle->tx_buffer[2] = byte_count;

//     // 清空数据区
//     memset(&handle->tx_buffer[3], 0, byte_count);

//     // 填充线圈数据
//     for (uint16_t i = 0; i < quantity; i++) {
//         bool coil_value;
//         if (ModbusRTU_GetCoil(handle, start_addr + i, &coil_value) == MODBUS_STATUS_OK && coil_value) {
//             uint8_t byte_index = i / 8;
//             uint8_t bit_index = i % 8;
//             handle->tx_buffer[3 + byte_index] |= (1 << bit_index);
//         }
//     }

//     uint16_t response_length = 3 + byte_count;

//     // 添加CRC
//     uint16_t crc = ModbusRTU_CalculateCRC16(handle->tx_buffer, response_length);
//     handle->tx_buffer[response_length] = crc & 0xFF;
//     handle->tx_buffer[response_length + 1] = (crc >> 8) & 0xFF;

//     return ModbusRTU_SendResponse(handle, handle->tx_buffer, response_length + 2);
// }

// /**
//  * @brief 处理读取离散输入请求
//  */
// static ModbusStatus_t ModbusRTU_ProcessReadDiscreteInputs(ModbusRTU_Handle_t *handle, uint16_t start_addr, uint16_t quantity)
// {
//     if (start_addr + quantity > MODBUS_MAX_REGISTERS || quantity == 0 || quantity > 2000) {
//         return ModbusRTU_SendException(handle, MODBUS_FC_READ_DISCRETE_INPUT, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS);
//     }

//     // 构造响应
//     handle->tx_buffer[0] = handle->slave_address;
//     handle->tx_buffer[1] = MODBUS_FC_READ_DISCRETE_INPUT;
//     uint8_t byte_count = (quantity + 7) / 8;
//     handle->tx_buffer[2] = byte_count;

//     // 清空数据区
//     memset(&handle->tx_buffer[3], 0, byte_count);

//     // 填充离散输入数据
//     for (uint16_t i = 0; i < quantity; i++) {
//         uint16_t byte_index = (start_addr + i) / 8;
//         uint8_t bit_index = (start_addr + i) % 8;
//         if (handle->discrete_inputs[byte_index] & (1 << bit_index)) {
//             uint8_t resp_byte_index = i / 8;
//             uint8_t resp_bit_index = i % 8;
//             handle->tx_buffer[3 + resp_byte_index] |= (1 << resp_bit_index);
//         }
//     }

//     uint16_t response_length = 3 + byte_count;

//     // 添加CRC
//     uint16_t crc = ModbusRTU_CalculateCRC16(handle->tx_buffer, response_length);
//     handle->tx_buffer[response_length] = crc & 0xFF;
//     handle->tx_buffer[response_length + 1] = (crc >> 8) & 0xFF;

//     return ModbusRTU_SendResponse(handle, handle->tx_buffer, response_length + 2);
// }

// /**
//  * @brief 处理写单个寄存器请求
//  */
// static ModbusStatus_t ModbusRTU_ProcessWriteSingleRegister(ModbusRTU_Handle_t *handle, uint16_t addr, uint16_t value)
// {
//     if (addr >= MODBUS_MAX_REGISTERS) {
//         return ModbusRTU_SendException(handle, MODBUS_FC_WRITE_SINGLE_REG, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS);
//     }

//     // 写入寄存器
//     handle->holding_registers[addr] = value;

//     // 构造响应（回显请求）
//     handle->tx_buffer[0] = handle->slave_address;
//     handle->tx_buffer[1] = MODBUS_FC_WRITE_SINGLE_REG;
//     handle->tx_buffer[2] = (addr >> 8) & 0xFF;
//     handle->tx_buffer[3] = addr & 0xFF;
//     handle->tx_buffer[4] = (value >> 8) & 0xFF;
//     handle->tx_buffer[5] = value & 0xFF;

//     uint16_t response_length = 6;

//     // 添加CRC
//     uint16_t crc = ModbusRTU_CalculateCRC16(handle->tx_buffer, response_length);
//     handle->tx_buffer[response_length] = crc & 0xFF;
//     handle->tx_buffer[response_length + 1] = (crc >> 8) & 0xFF;

//     return ModbusRTU_SendResponse(handle, handle->tx_buffer, response_length + 2);
// }

// /**
//  * @brief 处理写单个线圈请求
//  */
// static ModbusStatus_t ModbusRTU_ProcessWriteSingleCoil(ModbusRTU_Handle_t *handle, uint16_t addr, uint16_t value)
// {
//     if (addr >= MODBUS_MAX_REGISTERS) {
//         return ModbusRTU_SendException(handle, MODBUS_FC_WRITE_SINGLE_COIL, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS);
//     }

//     // 写入线圈
//     bool coil_value = (value == 0xFF00);
//     ModbusRTU_SetCoil(handle, addr, coil_value);

//     // 构造响应（回显请求）
//     handle->tx_buffer[0] = handle->slave_address;
//     handle->tx_buffer[1] = MODBUS_FC_WRITE_SINGLE_COIL;
//     handle->tx_buffer[2] = (addr >> 8) & 0xFF;
//     handle->tx_buffer[3] = addr & 0xFF;
//     handle->tx_buffer[4] = (value >> 8) & 0xFF;
//     handle->tx_buffer[5] = value & 0xFF;

//     uint16_t response_length = 6;

//     // 添加CRC
//     uint16_t crc = ModbusRTU_CalculateCRC16(handle->tx_buffer, response_length);
//     handle->tx_buffer[response_length] = crc & 0xFF;
//     handle->tx_buffer[response_length + 1] = (crc >> 8) & 0xFF;

//     return ModbusRTU_SendResponse(handle, handle->tx_buffer, response_length + 2);
// }

// /**
//  * @brief 发送响应
//  */
// static ModbusStatus_t ModbusRTU_SendResponse(ModbusRTU_Handle_t *handle, uint8_t *data, uint16_t length)
// {
//     if (handle == NULL || handle->uart_handle == NULL || data == NULL || length == 0) {
//         return MODBUS_STATUS_ERROR;
//     }

//     UART_4G_Status_t status = UART_4G_SendData(handle->uart_handle, data, length);
//     if (status == UART_4G_STATUS_SUCCESS) {
//         return MODBUS_STATUS_OK;
//     }

//     return MODBUS_STATUS_ERROR;
// }

// /**
//  * @brief 发送异常响应
//  */
// static ModbusStatus_t ModbusRTU_SendException(ModbusRTU_Handle_t *handle, uint8_t function_code, uint8_t exception_code)
// {
//     if (handle == NULL) {
//         return MODBUS_STATUS_ERROR;
//     }

//     // 构造异常响应
//     handle->tx_buffer[0] = handle->slave_address;
//     handle->tx_buffer[1] = function_code | 0x80;  // 设置最高位表示异常
//     handle->tx_buffer[2] = exception_code;

//     uint16_t response_length = 3;

//     // 添加CRC
//     uint16_t crc = ModbusRTU_CalculateCRC16(handle->tx_buffer, response_length);
//     handle->tx_buffer[response_length] = crc & 0xFF;
//     handle->tx_buffer[response_length + 1] = (crc >> 8) & 0xFF;

//     return ModbusRTU_SendResponse(handle, handle->tx_buffer, response_length + 2);
// }

// /**
//  * @brief 获取系统时钟滴答数
//  */
// static uint32_t ModbusRTU_GetTick(void)
// {
//     // 使用系统时钟获取当前时间
//     unsigned long ms;
//     mspm0_get_clock_ms(&ms);
//     return (uint32_t)ms;
// }

// /**
//  * @brief 检查帧是否完成
//  */
// static bool ModbusRTU_IsFrameComplete(ModbusRTU_Handle_t *handle)
// {
//     if (handle == NULL || handle->rx_count < 4) {
//         return false;
//     }

//     uint32_t current_time = ModbusRTU_GetTick();
    
//     // 如果距离最后一个字符接收超过3.5个字符时间，则认为帧结束
//     // 假设波特率为115200，一个字符约0.087ms，3.5个字符约0.3ms
//     // 为了安全起见，我们使用5ms作为帧间隔
//     if (current_time - handle->last_char_time > 5) {
//         return true;
//     }

//     return false;
// } 